//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Outposts service.
///
/// Amazon Web Services Outposts is a fully managed service that extends Amazon Web Services infrastructure, APIs, and tools to customer premises. By providing local access to Amazon Web Services managed infrastructure, Amazon Web Services Outposts enables customers to build and run applications on premises using the same programming interfaces as in Amazon Web Services Regions, while using local compute and storage resources for lower latency and local data processing needs.
public struct Outposts: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Outposts client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "Outposts",
            serviceIdentifier: "outposts",
            serviceProtocol: .restjson,
            apiVersion: "2019-12-03",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: OutpostsErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "ca-central-1": "outposts-fips.ca-central-1.amazonaws.com",
            "us-east-1": "outposts-fips.us-east-1.amazonaws.com",
            "us-east-2": "outposts-fips.us-east-2.amazonaws.com",
            "us-gov-east-1": "outposts.us-gov-east-1.amazonaws.com",
            "us-gov-west-1": "outposts.us-gov-west-1.amazonaws.com",
            "us-west-1": "outposts-fips.us-west-1.amazonaws.com",
            "us-west-2": "outposts-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Cancels the capacity task.
    @Sendable
    @inlinable
    public func cancelCapacityTask(_ input: CancelCapacityTaskInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelCapacityTaskOutput {
        try await self.client.execute(
            operation: "CancelCapacityTask", 
            path: "/outposts/{OutpostIdentifier}/capacity/{CapacityTaskId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels the capacity task.
    ///
    /// Parameters:
    ///   - capacityTaskId: ID of the capacity task that you want to cancel.
    ///   - outpostIdentifier: ID or ARN of the Outpost associated with the capacity task that you want to cancel.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelCapacityTask(
        capacityTaskId: String,
        outpostIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelCapacityTaskOutput {
        let input = CancelCapacityTaskInput(
            capacityTaskId: capacityTaskId, 
            outpostIdentifier: outpostIdentifier
        )
        return try await self.cancelCapacityTask(input, logger: logger)
    }

    /// Cancels the specified order for an Outpost.
    @Sendable
    @inlinable
    public func cancelOrder(_ input: CancelOrderInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelOrderOutput {
        try await self.client.execute(
            operation: "CancelOrder", 
            path: "/orders/{OrderId}/cancel", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels the specified order for an Outpost.
    ///
    /// Parameters:
    ///   - orderId:  The ID of the order.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelOrder(
        orderId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelOrderOutput {
        let input = CancelOrderInput(
            orderId: orderId
        )
        return try await self.cancelOrder(input, logger: logger)
    }

    /// Creates an order for an Outpost.
    @Sendable
    @inlinable
    public func createOrder(_ input: CreateOrderInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateOrderOutput {
        try await self.client.execute(
            operation: "CreateOrder", 
            path: "/orders", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an order for an Outpost.
    ///
    /// Parameters:
    ///   - lineItems: The line items that make up the order.
    ///   - outpostIdentifier:  The ID or the Amazon Resource Name (ARN) of the Outpost.
    ///   - paymentOption: The payment option.
    ///   - paymentTerm: The payment terms.
    ///   - logger: Logger use during operation
    @inlinable
    public func createOrder(
        lineItems: [LineItemRequest],
        outpostIdentifier: String,
        paymentOption: PaymentOption,
        paymentTerm: PaymentTerm? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateOrderOutput {
        let input = CreateOrderInput(
            lineItems: lineItems, 
            outpostIdentifier: outpostIdentifier, 
            paymentOption: paymentOption, 
            paymentTerm: paymentTerm
        )
        return try await self.createOrder(input, logger: logger)
    }

    /// Creates an Outpost. You can specify either an Availability one or an AZ ID.
    @Sendable
    @inlinable
    public func createOutpost(_ input: CreateOutpostInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateOutpostOutput {
        try await self.client.execute(
            operation: "CreateOutpost", 
            path: "/outposts", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Outpost. You can specify either an Availability one or an AZ ID.
    ///
    /// Parameters:
    ///   - availabilityZone: 
    ///   - availabilityZoneId: 
    ///   - description: 
    ///   - name: 
    ///   - siteId:  The ID or the Amazon Resource Name (ARN) of the site.
    ///   - supportedHardwareType:  The type of hardware for this Outpost.
    ///   - tags: The tags to apply to the Outpost.
    ///   - logger: Logger use during operation
    @inlinable
    public func createOutpost(
        availabilityZone: String? = nil,
        availabilityZoneId: String? = nil,
        description: String? = nil,
        name: String,
        siteId: String,
        supportedHardwareType: SupportedHardwareType? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateOutpostOutput {
        let input = CreateOutpostInput(
            availabilityZone: availabilityZone, 
            availabilityZoneId: availabilityZoneId, 
            description: description, 
            name: name, 
            siteId: siteId, 
            supportedHardwareType: supportedHardwareType, 
            tags: tags
        )
        return try await self.createOutpost(input, logger: logger)
    }

    ///  Creates a site for an Outpost.
    @Sendable
    @inlinable
    public func createSite(_ input: CreateSiteInput, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSiteOutput {
        try await self.client.execute(
            operation: "CreateSite", 
            path: "/sites", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates a site for an Outpost.
    ///
    /// Parameters:
    ///   - description: 
    ///   - name: 
    ///   - notes: Additional information that you provide about site access requirements, electrician scheduling, personal protective equipment, or regulation of equipment materials that could affect your installation process.
    ///   - operatingAddress:  The location to install and power on the hardware. This address might be different from the shipping address.
    ///   - rackPhysicalProperties:  Information about the physical and logistical details for the rack at this site. For more information about hardware requirements for racks, see Network  readiness checklist in the Amazon Web Services Outposts User Guide.
    ///   - shippingAddress:  The location to ship the hardware. This address might be different from the operating address.
    ///   - tags:  The tags to apply to a site.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSite(
        description: String? = nil,
        name: String,
        notes: String? = nil,
        operatingAddress: Address? = nil,
        rackPhysicalProperties: RackPhysicalProperties? = nil,
        shippingAddress: Address? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSiteOutput {
        let input = CreateSiteInput(
            description: description, 
            name: name, 
            notes: notes, 
            operatingAddress: operatingAddress, 
            rackPhysicalProperties: rackPhysicalProperties, 
            shippingAddress: shippingAddress, 
            tags: tags
        )
        return try await self.createSite(input, logger: logger)
    }

    /// Deletes the specified Outpost.
    @Sendable
    @inlinable
    public func deleteOutpost(_ input: DeleteOutpostInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteOutpostOutput {
        try await self.client.execute(
            operation: "DeleteOutpost", 
            path: "/outposts/{OutpostId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified Outpost.
    ///
    /// Parameters:
    ///   - outpostId:  The ID or ARN of the Outpost.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteOutpost(
        outpostId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteOutpostOutput {
        let input = DeleteOutpostInput(
            outpostId: outpostId
        )
        return try await self.deleteOutpost(input, logger: logger)
    }

    /// Deletes the specified site.
    @Sendable
    @inlinable
    public func deleteSite(_ input: DeleteSiteInput, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSiteOutput {
        try await self.client.execute(
            operation: "DeleteSite", 
            path: "/sites/{SiteId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified site.
    ///
    /// Parameters:
    ///   - siteId:  The ID or the Amazon Resource Name (ARN) of the site.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSite(
        siteId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSiteOutput {
        let input = DeleteSiteInput(
            siteId: siteId
        )
        return try await self.deleteSite(input, logger: logger)
    }

    /// Gets details of the specified capacity task.
    @Sendable
    @inlinable
    public func getCapacityTask(_ input: GetCapacityTaskInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCapacityTaskOutput {
        try await self.client.execute(
            operation: "GetCapacityTask", 
            path: "/outposts/{OutpostIdentifier}/capacity/{CapacityTaskId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets details of the specified capacity task.
    ///
    /// Parameters:
    ///   - capacityTaskId: ID of the capacity task.
    ///   - outpostIdentifier: ID or ARN of the Outpost associated with the specified capacity task.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCapacityTask(
        capacityTaskId: String,
        outpostIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCapacityTaskOutput {
        let input = GetCapacityTaskInput(
            capacityTaskId: capacityTaskId, 
            outpostIdentifier: outpostIdentifier
        )
        return try await self.getCapacityTask(input, logger: logger)
    }

    /// Gets information about the specified catalog item.
    @Sendable
    @inlinable
    public func getCatalogItem(_ input: GetCatalogItemInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCatalogItemOutput {
        try await self.client.execute(
            operation: "GetCatalogItem", 
            path: "/catalog/item/{CatalogItemId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about the specified catalog item.
    ///
    /// Parameters:
    ///   - catalogItemId: The ID of the catalog item.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCatalogItem(
        catalogItemId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCatalogItemOutput {
        let input = GetCatalogItemInput(
            catalogItemId: catalogItemId
        )
        return try await self.getCatalogItem(input, logger: logger)
    }

    ///   Amazon Web Services uses this action to install Outpost servers.  Gets information about the specified connection.   Use CloudTrail to monitor this action or Amazon Web Services managed policy for Amazon Web Services Outposts to secure it. For  more information, see  Amazon Web Services managed policies for Amazon Web Services Outposts and  Logging Amazon Web Services Outposts API calls with Amazon Web Services CloudTrail in the Amazon Web Services Outposts User Guide.
    @Sendable
    @inlinable
    public func getConnection(_ input: GetConnectionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetConnectionResponse {
        try await self.client.execute(
            operation: "GetConnection", 
            path: "/connections/{ConnectionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///   Amazon Web Services uses this action to install Outpost servers.  Gets information about the specified connection.   Use CloudTrail to monitor this action or Amazon Web Services managed policy for Amazon Web Services Outposts to secure it. For  more information, see  Amazon Web Services managed policies for Amazon Web Services Outposts and  Logging Amazon Web Services Outposts API calls with Amazon Web Services CloudTrail in the Amazon Web Services Outposts User Guide.
    ///
    /// Parameters:
    ///   - connectionId:  The ID of the connection.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConnection(
        connectionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConnectionResponse {
        let input = GetConnectionRequest(
            connectionId: connectionId
        )
        return try await self.getConnection(input, logger: logger)
    }

    /// Gets information about the specified order.
    @Sendable
    @inlinable
    public func getOrder(_ input: GetOrderInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetOrderOutput {
        try await self.client.execute(
            operation: "GetOrder", 
            path: "/orders/{OrderId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about the specified order.
    ///
    /// Parameters:
    ///   - orderId: The ID of the order.
    ///   - logger: Logger use during operation
    @inlinable
    public func getOrder(
        orderId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetOrderOutput {
        let input = GetOrderInput(
            orderId: orderId
        )
        return try await self.getOrder(input, logger: logger)
    }

    /// Gets information about the specified Outpost.
    @Sendable
    @inlinable
    public func getOutpost(_ input: GetOutpostInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetOutpostOutput {
        try await self.client.execute(
            operation: "GetOutpost", 
            path: "/outposts/{OutpostId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about the specified Outpost.
    ///
    /// Parameters:
    ///   - outpostId: The ID or ARN of the Outpost.
    ///   - logger: Logger use during operation
    @inlinable
    public func getOutpost(
        outpostId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetOutpostOutput {
        let input = GetOutpostInput(
            outpostId: outpostId
        )
        return try await self.getOutpost(input, logger: logger)
    }

    /// Gets current and historical billing information about the specified Outpost.
    @Sendable
    @inlinable
    public func getOutpostBillingInformation(_ input: GetOutpostBillingInformationInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetOutpostBillingInformationOutput {
        try await self.client.execute(
            operation: "GetOutpostBillingInformation", 
            path: "/outpost/{OutpostIdentifier}/billing-information", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets current and historical billing information about the specified Outpost.
    ///
    /// Parameters:
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - outpostIdentifier: The ID or ARN of the Outpost.
    ///   - logger: Logger use during operation
    @inlinable
    public func getOutpostBillingInformation(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        outpostIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetOutpostBillingInformationOutput {
        let input = GetOutpostBillingInformationInput(
            maxResults: maxResults, 
            nextToken: nextToken, 
            outpostIdentifier: outpostIdentifier
        )
        return try await self.getOutpostBillingInformation(input, logger: logger)
    }

    /// Gets the instance types for the specified Outpost.
    @Sendable
    @inlinable
    public func getOutpostInstanceTypes(_ input: GetOutpostInstanceTypesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetOutpostInstanceTypesOutput {
        try await self.client.execute(
            operation: "GetOutpostInstanceTypes", 
            path: "/outposts/{OutpostId}/instanceTypes", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the instance types for the specified Outpost.
    ///
    /// Parameters:
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - outpostId:  The ID or ARN of the Outpost.
    ///   - logger: Logger use during operation
    @inlinable
    public func getOutpostInstanceTypes(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        outpostId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetOutpostInstanceTypesOutput {
        let input = GetOutpostInstanceTypesInput(
            maxResults: maxResults, 
            nextToken: nextToken, 
            outpostId: outpostId
        )
        return try await self.getOutpostInstanceTypes(input, logger: logger)
    }

    /// Gets the instance types that an Outpost can support in InstanceTypeCapacity. This will generally include instance types that are not currently configured and therefore cannot be launched with the current Outpost capacity configuration.
    @Sendable
    @inlinable
    public func getOutpostSupportedInstanceTypes(_ input: GetOutpostSupportedInstanceTypesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetOutpostSupportedInstanceTypesOutput {
        try await self.client.execute(
            operation: "GetOutpostSupportedInstanceTypes", 
            path: "/outposts/{OutpostIdentifier}/supportedInstanceTypes", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the instance types that an Outpost can support in InstanceTypeCapacity. This will generally include instance types that are not currently configured and therefore cannot be launched with the current Outpost capacity configuration.
    ///
    /// Parameters:
    ///   - assetId: The ID of the Outpost asset. An Outpost asset can be a single server within an Outposts rack or an Outposts server configuration.
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - orderId: The ID for the Amazon Web Services Outposts order.
    ///   - outpostIdentifier: The ID or ARN of the Outpost.
    ///   - logger: Logger use during operation
    @inlinable
    public func getOutpostSupportedInstanceTypes(
        assetId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        orderId: String? = nil,
        outpostIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetOutpostSupportedInstanceTypesOutput {
        let input = GetOutpostSupportedInstanceTypesInput(
            assetId: assetId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            orderId: orderId, 
            outpostIdentifier: outpostIdentifier
        )
        return try await self.getOutpostSupportedInstanceTypes(input, logger: logger)
    }

    /// Gets information about the specified Outpost site.
    @Sendable
    @inlinable
    public func getSite(_ input: GetSiteInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSiteOutput {
        try await self.client.execute(
            operation: "GetSite", 
            path: "/sites/{SiteId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets information about the specified Outpost site.
    ///
    /// Parameters:
    ///   - siteId:  The ID or the Amazon Resource Name (ARN) of the site.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSite(
        siteId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSiteOutput {
        let input = GetSiteInput(
            siteId: siteId
        )
        return try await self.getSite(input, logger: logger)
    }

    ///  Gets the site address of the specified site.
    @Sendable
    @inlinable
    public func getSiteAddress(_ input: GetSiteAddressInput, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSiteAddressOutput {
        try await self.client.execute(
            operation: "GetSiteAddress", 
            path: "/sites/{SiteId}/address", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Gets the site address of the specified site.
    ///
    /// Parameters:
    ///   - addressType: The type of the address you request.
    ///   - siteId:  The ID or the Amazon Resource Name (ARN) of the site.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSiteAddress(
        addressType: AddressType,
        siteId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSiteAddressOutput {
        let input = GetSiteAddressInput(
            addressType: addressType, 
            siteId: siteId
        )
        return try await self.getSiteAddress(input, logger: logger)
    }

    /// A list of Amazon EC2 instances, belonging to all accounts, running on the specified Outpost. Does not include Amazon EBS or Amazon S3 instances.
    @Sendable
    @inlinable
    public func listAssetInstances(_ input: ListAssetInstancesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAssetInstancesOutput {
        try await self.client.execute(
            operation: "ListAssetInstances", 
            path: "/outposts/{OutpostIdentifier}/assetInstances", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// A list of Amazon EC2 instances, belonging to all accounts, running on the specified Outpost. Does not include Amazon EBS or Amazon S3 instances.
    ///
    /// Parameters:
    ///   - accountIdFilter: Filters the results by account ID.
    ///   - assetIdFilter: Filters the results by asset ID.
    ///   - awsServiceFilter: Filters the results by Amazon Web Services service.
    ///   - instanceTypeFilter: Filters the results by instance ID.
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - outpostIdentifier: The ID of the Outpost.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAssetInstances(
        accountIdFilter: [String]? = nil,
        assetIdFilter: [String]? = nil,
        awsServiceFilter: [AWSServiceName]? = nil,
        instanceTypeFilter: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        outpostIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAssetInstancesOutput {
        let input = ListAssetInstancesInput(
            accountIdFilter: accountIdFilter, 
            assetIdFilter: assetIdFilter, 
            awsServiceFilter: awsServiceFilter, 
            instanceTypeFilter: instanceTypeFilter, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            outpostIdentifier: outpostIdentifier
        )
        return try await self.listAssetInstances(input, logger: logger)
    }

    /// Lists the hardware assets for the specified Outpost. Use filters to return specific results. If you specify multiple filters, the results include only the resources that match  all of the specified filters. For a filter where you can specify multiple values, the results include  items that match any of the values that you specify for the filter.
    @Sendable
    @inlinable
    public func listAssets(_ input: ListAssetsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAssetsOutput {
        try await self.client.execute(
            operation: "ListAssets", 
            path: "/outposts/{OutpostIdentifier}/assets", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the hardware assets for the specified Outpost. Use filters to return specific results. If you specify multiple filters, the results include only the resources that match  all of the specified filters. For a filter where you can specify multiple values, the results include  items that match any of the values that you specify for the filter.
    ///
    /// Parameters:
    ///   - hostIdFilter: Filters the results by the host ID of a Dedicated Host.
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - outpostIdentifier:  The ID or the Amazon Resource Name (ARN) of the Outpost.
    ///   - statusFilter: Filters the results by state.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAssets(
        hostIdFilter: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        outpostIdentifier: String,
        statusFilter: [AssetState]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAssetsOutput {
        let input = ListAssetsInput(
            hostIdFilter: hostIdFilter, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            outpostIdentifier: outpostIdentifier, 
            statusFilter: statusFilter
        )
        return try await self.listAssets(input, logger: logger)
    }

    /// A list of Amazon EC2 instances running on the Outpost and belonging to the account that initiated the capacity task. Use this list to specify the instances you cannot stop to free up capacity to run the capacity task.
    @Sendable
    @inlinable
    public func listBlockingInstancesForCapacityTask(_ input: ListBlockingInstancesForCapacityTaskInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListBlockingInstancesForCapacityTaskOutput {
        try await self.client.execute(
            operation: "ListBlockingInstancesForCapacityTask", 
            path: "/outposts/{OutpostIdentifier}/capacity/{CapacityTaskId}/blockingInstances", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// A list of Amazon EC2 instances running on the Outpost and belonging to the account that initiated the capacity task. Use this list to specify the instances you cannot stop to free up capacity to run the capacity task.
    ///
    /// Parameters:
    ///   - capacityTaskId: The ID of the capacity task.
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - outpostIdentifier: The ID or ARN of the Outpost associated with the specified capacity task.
    ///   - logger: Logger use during operation
    @inlinable
    public func listBlockingInstancesForCapacityTask(
        capacityTaskId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        outpostIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListBlockingInstancesForCapacityTaskOutput {
        let input = ListBlockingInstancesForCapacityTaskInput(
            capacityTaskId: capacityTaskId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            outpostIdentifier: outpostIdentifier
        )
        return try await self.listBlockingInstancesForCapacityTask(input, logger: logger)
    }

    /// Lists the capacity tasks for your Amazon Web Services account. Use filters to return specific results. If you specify multiple filters, the results include only the resources that match  all of the specified filters. For a filter where you can specify multiple values, the results include  items that match any of the values that you specify for the filter.
    @Sendable
    @inlinable
    public func listCapacityTasks(_ input: ListCapacityTasksInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCapacityTasksOutput {
        try await self.client.execute(
            operation: "ListCapacityTasks", 
            path: "/capacity/tasks", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the capacity tasks for your Amazon Web Services account. Use filters to return specific results. If you specify multiple filters, the results include only the resources that match  all of the specified filters. For a filter where you can specify multiple values, the results include  items that match any of the values that you specify for the filter.
    ///
    /// Parameters:
    ///   - capacityTaskStatusFilter: A list of statuses. For example, REQUESTED or WAITING_FOR_EVACUATION.
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - outpostIdentifierFilter: Filters the results by an Outpost ID or an Outpost ARN.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCapacityTasks(
        capacityTaskStatusFilter: [CapacityTaskStatus]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        outpostIdentifierFilter: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCapacityTasksOutput {
        let input = ListCapacityTasksInput(
            capacityTaskStatusFilter: capacityTaskStatusFilter, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            outpostIdentifierFilter: outpostIdentifierFilter
        )
        return try await self.listCapacityTasks(input, logger: logger)
    }

    /// Lists the items in the catalog. Use filters to return specific results. If you specify multiple filters, the results include only the resources that match  all of the specified filters. For a filter where you can specify multiple values, the results include  items that match any of the values that you specify for the filter.
    @Sendable
    @inlinable
    public func listCatalogItems(_ input: ListCatalogItemsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCatalogItemsOutput {
        try await self.client.execute(
            operation: "ListCatalogItems", 
            path: "/catalog/items", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the items in the catalog. Use filters to return specific results. If you specify multiple filters, the results include only the resources that match  all of the specified filters. For a filter where you can specify multiple values, the results include  items that match any of the values that you specify for the filter.
    ///
    /// Parameters:
    ///   - ec2FamilyFilter: Filters the results by EC2 family (for example, M5).
    ///   - itemClassFilter: Filters the results by item class.
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - supportedStorageFilter: Filters the results by storage option.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCatalogItems(
        ec2FamilyFilter: [String]? = nil,
        itemClassFilter: [CatalogItemClass]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        supportedStorageFilter: [SupportedStorageEnum]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCatalogItemsOutput {
        let input = ListCatalogItemsInput(
            ec2FamilyFilter: ec2FamilyFilter, 
            itemClassFilter: itemClassFilter, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            supportedStorageFilter: supportedStorageFilter
        )
        return try await self.listCatalogItems(input, logger: logger)
    }

    /// Lists the Outpost orders for your Amazon Web Services account.
    @Sendable
    @inlinable
    public func listOrders(_ input: ListOrdersInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOrdersOutput {
        try await self.client.execute(
            operation: "ListOrders", 
            path: "/list-orders", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the Outpost orders for your Amazon Web Services account.
    ///
    /// Parameters:
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - outpostIdentifierFilter:  The ID or the Amazon Resource Name (ARN) of the Outpost.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOrders(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        outpostIdentifierFilter: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOrdersOutput {
        let input = ListOrdersInput(
            maxResults: maxResults, 
            nextToken: nextToken, 
            outpostIdentifierFilter: outpostIdentifierFilter
        )
        return try await self.listOrders(input, logger: logger)
    }

    /// Lists the Outposts for your Amazon Web Services account. Use filters to return specific results. If you specify multiple filters, the results include only the resources that match  all of the specified filters. For a filter where you can specify multiple values, the results include  items that match any of the values that you specify for the filter.
    @Sendable
    @inlinable
    public func listOutposts(_ input: ListOutpostsInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOutpostsOutput {
        try await self.client.execute(
            operation: "ListOutposts", 
            path: "/outposts", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the Outposts for your Amazon Web Services account. Use filters to return specific results. If you specify multiple filters, the results include only the resources that match  all of the specified filters. For a filter where you can specify multiple values, the results include  items that match any of the values that you specify for the filter.
    ///
    /// Parameters:
    ///   - availabilityZoneFilter: Filters the results by Availability Zone (for example, us-east-1a).
    ///   - availabilityZoneIdFilter: Filters the results by AZ ID (for example, use1-az1).
    ///   - lifeCycleStatusFilter: Filters the results by the lifecycle status.
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - logger: Logger use during operation
    @inlinable
    public func listOutposts(
        availabilityZoneFilter: [String]? = nil,
        availabilityZoneIdFilter: [String]? = nil,
        lifeCycleStatusFilter: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOutpostsOutput {
        let input = ListOutpostsInput(
            availabilityZoneFilter: availabilityZoneFilter, 
            availabilityZoneIdFilter: availabilityZoneIdFilter, 
            lifeCycleStatusFilter: lifeCycleStatusFilter, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listOutposts(input, logger: logger)
    }

    /// Lists the Outpost sites for your Amazon Web Services account. Use filters to return specific results. Use filters to return specific results. If you specify multiple filters, the results include only the resources that match  all of the specified filters. For a filter where you can specify multiple values, the results include  items that match any of the values that you specify for the filter.
    @Sendable
    @inlinable
    public func listSites(_ input: ListSitesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSitesOutput {
        try await self.client.execute(
            operation: "ListSites", 
            path: "/sites", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the Outpost sites for your Amazon Web Services account. Use filters to return specific results. Use filters to return specific results. If you specify multiple filters, the results include only the resources that match  all of the specified filters. For a filter where you can specify multiple values, the results include  items that match any of the values that you specify for the filter.
    ///
    /// Parameters:
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - operatingAddressCityFilter: Filters the results by city.
    ///   - operatingAddressCountryCodeFilter: Filters the results by country code.
    ///   - operatingAddressStateOrRegionFilter: Filters the results by state or region.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSites(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        operatingAddressCityFilter: [String]? = nil,
        operatingAddressCountryCodeFilter: [String]? = nil,
        operatingAddressStateOrRegionFilter: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSitesOutput {
        let input = ListSitesInput(
            maxResults: maxResults, 
            nextToken: nextToken, 
            operatingAddressCityFilter: operatingAddressCityFilter, 
            operatingAddressCountryCodeFilter: operatingAddressCountryCodeFilter, 
            operatingAddressStateOrRegionFilter: operatingAddressStateOrRegionFilter
        )
        return try await self.listSites(input, logger: logger)
    }

    /// Lists the tags for the specified resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the tags for the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Starts the specified capacity task. You can have one active capacity task for each order and each Outpost.
    @Sendable
    @inlinable
    public func startCapacityTask(_ input: StartCapacityTaskInput, logger: Logger = AWSClient.loggingDisabled) async throws -> StartCapacityTaskOutput {
        try await self.client.execute(
            operation: "StartCapacityTask", 
            path: "/outposts/{OutpostIdentifier}/capacity", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts the specified capacity task. You can have one active capacity task for each order and each Outpost.
    ///
    /// Parameters:
    ///   - assetId: The ID of the Outpost asset. An Outpost asset can be a single server within an Outposts rack or an Outposts server configuration.
    ///   - dryRun: You can request a dry run to determine if the instance type and instance size changes is above or below available instance capacity. Requesting a dry run does not make any changes to your plan.
    ///   - instancePools: The instance pools specified in the capacity task.
    ///   - instancesToExclude: List of user-specified running instances that must not be stopped in order to free up the capacity needed to run the capacity task.
    ///   - orderId: The ID of the Amazon Web Services Outposts order associated with the specified capacity task.
    ///   - outpostIdentifier: The ID or ARN of the Outposts associated with the specified capacity task.
    ///   - taskActionOnBlockingInstances: Specify one of the following options in case an instance is blocking the capacity task from running.    WAIT_FOR_EVACUATION - Checks every 10 minutes over 48 hours to determine if instances have stopped and capacity is available to complete the task.    FAIL_TASK - The capacity task fails.
    ///   - logger: Logger use during operation
    @inlinable
    public func startCapacityTask(
        assetId: String? = nil,
        dryRun: Bool? = nil,
        instancePools: [InstanceTypeCapacity],
        instancesToExclude: InstancesToExclude? = nil,
        orderId: String? = nil,
        outpostIdentifier: String,
        taskActionOnBlockingInstances: TaskActionOnBlockingInstances? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartCapacityTaskOutput {
        let input = StartCapacityTaskInput(
            assetId: assetId, 
            dryRun: dryRun, 
            instancePools: instancePools, 
            instancesToExclude: instancesToExclude, 
            orderId: orderId, 
            outpostIdentifier: outpostIdentifier, 
            taskActionOnBlockingInstances: taskActionOnBlockingInstances
        )
        return try await self.startCapacityTask(input, logger: logger)
    }

    ///   Amazon Web Services uses this action to install Outpost servers.  Starts the connection required for Outpost server installation.   Use CloudTrail to monitor this action or Amazon Web Services managed policy for Amazon Web Services Outposts to secure it. For  more information, see  Amazon Web Services managed policies for Amazon Web Services Outposts and  Logging Amazon Web Services Outposts API calls with Amazon Web Services CloudTrail in the Amazon Web Services Outposts User Guide.
    @Sendable
    @inlinable
    public func startConnection(_ input: StartConnectionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartConnectionResponse {
        try await self.client.execute(
            operation: "StartConnection", 
            path: "/connections", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///   Amazon Web Services uses this action to install Outpost servers.  Starts the connection required for Outpost server installation.   Use CloudTrail to monitor this action or Amazon Web Services managed policy for Amazon Web Services Outposts to secure it. For  more information, see  Amazon Web Services managed policies for Amazon Web Services Outposts and  Logging Amazon Web Services Outposts API calls with Amazon Web Services CloudTrail in the Amazon Web Services Outposts User Guide.
    ///
    /// Parameters:
    ///   - assetId:  The ID of the Outpost server.
    ///   - clientPublicKey:  The public key of the client.
    ///   - deviceSerialNumber:  The serial number of the dongle.
    ///   - networkInterfaceDeviceIndex:  The device index of the network interface on the Outpost server.
    ///   - logger: Logger use during operation
    @inlinable
    public func startConnection(
        assetId: String,
        clientPublicKey: String,
        deviceSerialNumber: String? = nil,
        networkInterfaceDeviceIndex: Int = 0,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartConnectionResponse {
        let input = StartConnectionRequest(
            assetId: assetId, 
            clientPublicKey: clientPublicKey, 
            deviceSerialNumber: deviceSerialNumber, 
            networkInterfaceDeviceIndex: networkInterfaceDeviceIndex
        )
        return try await self.startConnection(input, logger: logger)
    }

    /// Adds tags to the specified resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds tags to the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tags: The tags to add to the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes tags from the specified resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes tags from the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tagKeys: The tag keys.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    ///  Updates an Outpost.
    @Sendable
    @inlinable
    public func updateOutpost(_ input: UpdateOutpostInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateOutpostOutput {
        try await self.client.execute(
            operation: "UpdateOutpost", 
            path: "/outposts/{OutpostId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Updates an Outpost.
    ///
    /// Parameters:
    ///   - description: 
    ///   - name: 
    ///   - outpostId:  The ID or ARN of the Outpost.
    ///   - supportedHardwareType:  The type of hardware for this Outpost.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateOutpost(
        description: String? = nil,
        name: String? = nil,
        outpostId: String,
        supportedHardwareType: SupportedHardwareType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateOutpostOutput {
        let input = UpdateOutpostInput(
            description: description, 
            name: name, 
            outpostId: outpostId, 
            supportedHardwareType: supportedHardwareType
        )
        return try await self.updateOutpost(input, logger: logger)
    }

    /// Updates the specified site.
    @Sendable
    @inlinable
    public func updateSite(_ input: UpdateSiteInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSiteOutput {
        try await self.client.execute(
            operation: "UpdateSite", 
            path: "/sites/{SiteId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the specified site.
    ///
    /// Parameters:
    ///   - description: 
    ///   - name: 
    ///   - notes: Notes about a site.
    ///   - siteId:  The ID or the Amazon Resource Name (ARN) of the site.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSite(
        description: String? = nil,
        name: String? = nil,
        notes: String? = nil,
        siteId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSiteOutput {
        let input = UpdateSiteInput(
            description: description, 
            name: name, 
            notes: notes, 
            siteId: siteId
        )
        return try await self.updateSite(input, logger: logger)
    }

    /// Updates the address of the specified site. You can't update a site address if there is an order in progress. You must wait for the order to complete or cancel the order. You can update the operating address before you place an order at the site, or after all Outposts that belong to the site have been deactivated.
    @Sendable
    @inlinable
    public func updateSiteAddress(_ input: UpdateSiteAddressInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSiteAddressOutput {
        try await self.client.execute(
            operation: "UpdateSiteAddress", 
            path: "/sites/{SiteId}/address", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the address of the specified site. You can't update a site address if there is an order in progress. You must wait for the order to complete or cancel the order. You can update the operating address before you place an order at the site, or after all Outposts that belong to the site have been deactivated.
    ///
    /// Parameters:
    ///   - address:  The address for the site.
    ///   - addressType:  The type of the address.
    ///   - siteId:  The ID or the Amazon Resource Name (ARN) of the site.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSiteAddress(
        address: Address,
        addressType: AddressType,
        siteId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSiteAddressOutput {
        let input = UpdateSiteAddressInput(
            address: address, 
            addressType: addressType, 
            siteId: siteId
        )
        return try await self.updateSiteAddress(input, logger: logger)
    }

    /// Update the physical and logistical details for a rack at a site. For more information about hardware requirements for racks, see Network  readiness checklist in the Amazon Web Services Outposts User Guide.  To update a rack at a site with an order of IN_PROGRESS, you must wait for the order to complete or cancel the order.
    @Sendable
    @inlinable
    public func updateSiteRackPhysicalProperties(_ input: UpdateSiteRackPhysicalPropertiesInput, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSiteRackPhysicalPropertiesOutput {
        try await self.client.execute(
            operation: "UpdateSiteRackPhysicalProperties", 
            path: "/sites/{SiteId}/rackPhysicalProperties", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update the physical and logistical details for a rack at a site. For more information about hardware requirements for racks, see Network  readiness checklist in the Amazon Web Services Outposts User Guide.  To update a rack at a site with an order of IN_PROGRESS, you must wait for the order to complete or cancel the order.
    ///
    /// Parameters:
    ///   - fiberOpticCableType: The type of fiber that you will use to attach the Outpost to your network.
    ///   - maximumSupportedWeightLbs: The maximum rack weight that this site can support. NO_LIMIT is over 2000lbs.
    ///   - opticalStandard: The type of optical standard that you will use to attach the Outpost to your network. This field is dependent on uplink speed, fiber type, and distance to the upstream device. For more information about networking requirements for racks, see Network  in the Amazon Web Services Outposts User Guide.     OPTIC_10GBASE_SR: 10GBASE-SR    OPTIC_10GBASE_IR: 10GBASE-IR    OPTIC_10GBASE_LR: 10GBASE-LR    OPTIC_40GBASE_SR: 40GBASE-SR    OPTIC_40GBASE_ESR: 40GBASE-ESR    OPTIC_40GBASE_IR4_LR4L: 40GBASE-IR (LR4L)    OPTIC_40GBASE_LR4: 40GBASE-LR4    OPTIC_100GBASE_SR4: 100GBASE-SR4    OPTIC_100GBASE_CWDM4: 100GBASE-CWDM4    OPTIC_100GBASE_LR4: 100GBASE-LR4    OPTIC_100G_PSM4_MSA: 100G PSM4 MSA    OPTIC_1000BASE_LX: 1000Base-LX    OPTIC_1000BASE_SX : 1000Base-SX
    ///   - powerConnector: The power connector that Amazon Web Services should plan to provide for connections to the hardware. Note the correlation between PowerPhase and PowerConnector.    Single-phase AC feed    L6-30P – (common in US); 30A; single phase    IEC309 (blue) – P+N+E, 6hr; 32 A; single phase     Three-phase AC feed    AH530P7W (red) – 3P+N+E, 7hr; 30A; three phase    AH532P6W (red) – 3P+N+E, 6hr; 32A; three phase    CS8365C – (common in US); 3P+E, 50A; three phase
    ///   - powerDrawKva: The power draw, in kVA, available at the hardware placement position for the rack.
    ///   - powerFeedDrop: Indicates whether the power feed comes above or below the rack.
    ///   - powerPhase: The power option that you can provide for hardware.    Single-phase AC feed: 200 V to 277 V, 50 Hz or 60 Hz   Three-phase AC feed: 346 V to 480 V, 50 Hz or 60 Hz
    ///   - siteId:  The ID or the Amazon Resource Name (ARN) of the site.
    ///   - uplinkCount: Racks come with two Outpost network devices. Depending on the supported uplink speed at the site, the Outpost network devices provide a variable number of uplinks. Specify the number of uplinks for each Outpost network device that you intend to use to connect the rack to your network. Note the correlation between UplinkGbps and UplinkCount.    1Gbps - Uplinks available: 1, 2, 4, 6, 8   10Gbps - Uplinks available: 1, 2, 4, 8, 12, 16   40 and 100 Gbps- Uplinks available: 1, 2, 4
    ///   - uplinkGbps: The uplink speed the rack should support for the connection to the Region.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSiteRackPhysicalProperties(
        fiberOpticCableType: FiberOpticCableType? = nil,
        maximumSupportedWeightLbs: MaximumSupportedWeightLbs? = nil,
        opticalStandard: OpticalStandard? = nil,
        powerConnector: PowerConnector? = nil,
        powerDrawKva: PowerDrawKva? = nil,
        powerFeedDrop: PowerFeedDrop? = nil,
        powerPhase: PowerPhase? = nil,
        siteId: String,
        uplinkCount: UplinkCount? = nil,
        uplinkGbps: UplinkGbps? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSiteRackPhysicalPropertiesOutput {
        let input = UpdateSiteRackPhysicalPropertiesInput(
            fiberOpticCableType: fiberOpticCableType, 
            maximumSupportedWeightLbs: maximumSupportedWeightLbs, 
            opticalStandard: opticalStandard, 
            powerConnector: powerConnector, 
            powerDrawKva: powerDrawKva, 
            powerFeedDrop: powerFeedDrop, 
            powerPhase: powerPhase, 
            siteId: siteId, 
            uplinkCount: uplinkCount, 
            uplinkGbps: uplinkGbps
        )
        return try await self.updateSiteRackPhysicalProperties(input, logger: logger)
    }
}

extension Outposts {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Outposts, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Outposts {
    /// Return PaginatorSequence for operation ``getOutpostBillingInformation(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getOutpostBillingInformationPaginator(
        _ input: GetOutpostBillingInformationInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetOutpostBillingInformationInput, GetOutpostBillingInformationOutput> {
        return .init(
            input: input,
            command: self.getOutpostBillingInformation,
            inputKey: \GetOutpostBillingInformationInput.nextToken,
            outputKey: \GetOutpostBillingInformationOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getOutpostBillingInformation(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: 
    ///   - outpostIdentifier: The ID or ARN of the Outpost.
    ///   - logger: Logger used for logging
    @inlinable
    public func getOutpostBillingInformationPaginator(
        maxResults: Int? = nil,
        outpostIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetOutpostBillingInformationInput, GetOutpostBillingInformationOutput> {
        let input = GetOutpostBillingInformationInput(
            maxResults: maxResults, 
            outpostIdentifier: outpostIdentifier
        )
        return self.getOutpostBillingInformationPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getOutpostInstanceTypes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getOutpostInstanceTypesPaginator(
        _ input: GetOutpostInstanceTypesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetOutpostInstanceTypesInput, GetOutpostInstanceTypesOutput> {
        return .init(
            input: input,
            command: self.getOutpostInstanceTypes,
            inputKey: \GetOutpostInstanceTypesInput.nextToken,
            outputKey: \GetOutpostInstanceTypesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getOutpostInstanceTypes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: 
    ///   - outpostId:  The ID or ARN of the Outpost.
    ///   - logger: Logger used for logging
    @inlinable
    public func getOutpostInstanceTypesPaginator(
        maxResults: Int? = nil,
        outpostId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetOutpostInstanceTypesInput, GetOutpostInstanceTypesOutput> {
        let input = GetOutpostInstanceTypesInput(
            maxResults: maxResults, 
            outpostId: outpostId
        )
        return self.getOutpostInstanceTypesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getOutpostSupportedInstanceTypes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getOutpostSupportedInstanceTypesPaginator(
        _ input: GetOutpostSupportedInstanceTypesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetOutpostSupportedInstanceTypesInput, GetOutpostSupportedInstanceTypesOutput> {
        return .init(
            input: input,
            command: self.getOutpostSupportedInstanceTypes,
            inputKey: \GetOutpostSupportedInstanceTypesInput.nextToken,
            outputKey: \GetOutpostSupportedInstanceTypesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getOutpostSupportedInstanceTypes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - assetId: The ID of the Outpost asset. An Outpost asset can be a single server within an Outposts rack or an Outposts server configuration.
    ///   - maxResults: 
    ///   - orderId: The ID for the Amazon Web Services Outposts order.
    ///   - outpostIdentifier: The ID or ARN of the Outpost.
    ///   - logger: Logger used for logging
    @inlinable
    public func getOutpostSupportedInstanceTypesPaginator(
        assetId: String? = nil,
        maxResults: Int? = nil,
        orderId: String? = nil,
        outpostIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetOutpostSupportedInstanceTypesInput, GetOutpostSupportedInstanceTypesOutput> {
        let input = GetOutpostSupportedInstanceTypesInput(
            assetId: assetId, 
            maxResults: maxResults, 
            orderId: orderId, 
            outpostIdentifier: outpostIdentifier
        )
        return self.getOutpostSupportedInstanceTypesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAssetInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssetInstancesPaginator(
        _ input: ListAssetInstancesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAssetInstancesInput, ListAssetInstancesOutput> {
        return .init(
            input: input,
            command: self.listAssetInstances,
            inputKey: \ListAssetInstancesInput.nextToken,
            outputKey: \ListAssetInstancesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAssetInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountIdFilter: Filters the results by account ID.
    ///   - assetIdFilter: Filters the results by asset ID.
    ///   - awsServiceFilter: Filters the results by Amazon Web Services service.
    ///   - instanceTypeFilter: Filters the results by instance ID.
    ///   - maxResults: 
    ///   - outpostIdentifier: The ID of the Outpost.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssetInstancesPaginator(
        accountIdFilter: [String]? = nil,
        assetIdFilter: [String]? = nil,
        awsServiceFilter: [AWSServiceName]? = nil,
        instanceTypeFilter: [String]? = nil,
        maxResults: Int? = nil,
        outpostIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAssetInstancesInput, ListAssetInstancesOutput> {
        let input = ListAssetInstancesInput(
            accountIdFilter: accountIdFilter, 
            assetIdFilter: assetIdFilter, 
            awsServiceFilter: awsServiceFilter, 
            instanceTypeFilter: instanceTypeFilter, 
            maxResults: maxResults, 
            outpostIdentifier: outpostIdentifier
        )
        return self.listAssetInstancesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAssets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssetsPaginator(
        _ input: ListAssetsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAssetsInput, ListAssetsOutput> {
        return .init(
            input: input,
            command: self.listAssets,
            inputKey: \ListAssetsInput.nextToken,
            outputKey: \ListAssetsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAssets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - hostIdFilter: Filters the results by the host ID of a Dedicated Host.
    ///   - maxResults: 
    ///   - outpostIdentifier:  The ID or the Amazon Resource Name (ARN) of the Outpost.
    ///   - statusFilter: Filters the results by state.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAssetsPaginator(
        hostIdFilter: [String]? = nil,
        maxResults: Int? = nil,
        outpostIdentifier: String,
        statusFilter: [AssetState]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAssetsInput, ListAssetsOutput> {
        let input = ListAssetsInput(
            hostIdFilter: hostIdFilter, 
            maxResults: maxResults, 
            outpostIdentifier: outpostIdentifier, 
            statusFilter: statusFilter
        )
        return self.listAssetsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listBlockingInstancesForCapacityTask(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listBlockingInstancesForCapacityTaskPaginator(
        _ input: ListBlockingInstancesForCapacityTaskInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListBlockingInstancesForCapacityTaskInput, ListBlockingInstancesForCapacityTaskOutput> {
        return .init(
            input: input,
            command: self.listBlockingInstancesForCapacityTask,
            inputKey: \ListBlockingInstancesForCapacityTaskInput.nextToken,
            outputKey: \ListBlockingInstancesForCapacityTaskOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listBlockingInstancesForCapacityTask(_:logger:)``.
    ///
    /// - Parameters:
    ///   - capacityTaskId: The ID of the capacity task.
    ///   - maxResults: 
    ///   - outpostIdentifier: The ID or ARN of the Outpost associated with the specified capacity task.
    ///   - logger: Logger used for logging
    @inlinable
    public func listBlockingInstancesForCapacityTaskPaginator(
        capacityTaskId: String,
        maxResults: Int? = nil,
        outpostIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListBlockingInstancesForCapacityTaskInput, ListBlockingInstancesForCapacityTaskOutput> {
        let input = ListBlockingInstancesForCapacityTaskInput(
            capacityTaskId: capacityTaskId, 
            maxResults: maxResults, 
            outpostIdentifier: outpostIdentifier
        )
        return self.listBlockingInstancesForCapacityTaskPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCapacityTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCapacityTasksPaginator(
        _ input: ListCapacityTasksInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCapacityTasksInput, ListCapacityTasksOutput> {
        return .init(
            input: input,
            command: self.listCapacityTasks,
            inputKey: \ListCapacityTasksInput.nextToken,
            outputKey: \ListCapacityTasksOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCapacityTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - capacityTaskStatusFilter: A list of statuses. For example, REQUESTED or WAITING_FOR_EVACUATION.
    ///   - maxResults: 
    ///   - outpostIdentifierFilter: Filters the results by an Outpost ID or an Outpost ARN.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCapacityTasksPaginator(
        capacityTaskStatusFilter: [CapacityTaskStatus]? = nil,
        maxResults: Int? = nil,
        outpostIdentifierFilter: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCapacityTasksInput, ListCapacityTasksOutput> {
        let input = ListCapacityTasksInput(
            capacityTaskStatusFilter: capacityTaskStatusFilter, 
            maxResults: maxResults, 
            outpostIdentifierFilter: outpostIdentifierFilter
        )
        return self.listCapacityTasksPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCatalogItems(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCatalogItemsPaginator(
        _ input: ListCatalogItemsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCatalogItemsInput, ListCatalogItemsOutput> {
        return .init(
            input: input,
            command: self.listCatalogItems,
            inputKey: \ListCatalogItemsInput.nextToken,
            outputKey: \ListCatalogItemsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCatalogItems(_:logger:)``.
    ///
    /// - Parameters:
    ///   - ec2FamilyFilter: Filters the results by EC2 family (for example, M5).
    ///   - itemClassFilter: Filters the results by item class.
    ///   - maxResults: 
    ///   - supportedStorageFilter: Filters the results by storage option.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCatalogItemsPaginator(
        ec2FamilyFilter: [String]? = nil,
        itemClassFilter: [CatalogItemClass]? = nil,
        maxResults: Int? = nil,
        supportedStorageFilter: [SupportedStorageEnum]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCatalogItemsInput, ListCatalogItemsOutput> {
        let input = ListCatalogItemsInput(
            ec2FamilyFilter: ec2FamilyFilter, 
            itemClassFilter: itemClassFilter, 
            maxResults: maxResults, 
            supportedStorageFilter: supportedStorageFilter
        )
        return self.listCatalogItemsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listOrders(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listOrdersPaginator(
        _ input: ListOrdersInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListOrdersInput, ListOrdersOutput> {
        return .init(
            input: input,
            command: self.listOrders,
            inputKey: \ListOrdersInput.nextToken,
            outputKey: \ListOrdersOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listOrders(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: 
    ///   - outpostIdentifierFilter:  The ID or the Amazon Resource Name (ARN) of the Outpost.
    ///   - logger: Logger used for logging
    @inlinable
    public func listOrdersPaginator(
        maxResults: Int? = nil,
        outpostIdentifierFilter: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListOrdersInput, ListOrdersOutput> {
        let input = ListOrdersInput(
            maxResults: maxResults, 
            outpostIdentifierFilter: outpostIdentifierFilter
        )
        return self.listOrdersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listOutposts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listOutpostsPaginator(
        _ input: ListOutpostsInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListOutpostsInput, ListOutpostsOutput> {
        return .init(
            input: input,
            command: self.listOutposts,
            inputKey: \ListOutpostsInput.nextToken,
            outputKey: \ListOutpostsOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listOutposts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - availabilityZoneFilter: Filters the results by Availability Zone (for example, us-east-1a).
    ///   - availabilityZoneIdFilter: Filters the results by AZ ID (for example, use1-az1).
    ///   - lifeCycleStatusFilter: Filters the results by the lifecycle status.
    ///   - maxResults: 
    ///   - logger: Logger used for logging
    @inlinable
    public func listOutpostsPaginator(
        availabilityZoneFilter: [String]? = nil,
        availabilityZoneIdFilter: [String]? = nil,
        lifeCycleStatusFilter: [String]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListOutpostsInput, ListOutpostsOutput> {
        let input = ListOutpostsInput(
            availabilityZoneFilter: availabilityZoneFilter, 
            availabilityZoneIdFilter: availabilityZoneIdFilter, 
            lifeCycleStatusFilter: lifeCycleStatusFilter, 
            maxResults: maxResults
        )
        return self.listOutpostsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSites(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSitesPaginator(
        _ input: ListSitesInput,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSitesInput, ListSitesOutput> {
        return .init(
            input: input,
            command: self.listSites,
            inputKey: \ListSitesInput.nextToken,
            outputKey: \ListSitesOutput.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSites(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: 
    ///   - operatingAddressCityFilter: Filters the results by city.
    ///   - operatingAddressCountryCodeFilter: Filters the results by country code.
    ///   - operatingAddressStateOrRegionFilter: Filters the results by state or region.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSitesPaginator(
        maxResults: Int? = nil,
        operatingAddressCityFilter: [String]? = nil,
        operatingAddressCountryCodeFilter: [String]? = nil,
        operatingAddressStateOrRegionFilter: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSitesInput, ListSitesOutput> {
        let input = ListSitesInput(
            maxResults: maxResults, 
            operatingAddressCityFilter: operatingAddressCityFilter, 
            operatingAddressCountryCodeFilter: operatingAddressCountryCodeFilter, 
            operatingAddressStateOrRegionFilter: operatingAddressStateOrRegionFilter
        )
        return self.listSitesPaginator(input, logger: logger)
    }
}

extension Outposts.GetOutpostBillingInformationInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Outposts.GetOutpostBillingInformationInput {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            outpostIdentifier: self.outpostIdentifier
        )
    }
}

extension Outposts.GetOutpostInstanceTypesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Outposts.GetOutpostInstanceTypesInput {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            outpostId: self.outpostId
        )
    }
}

extension Outposts.GetOutpostSupportedInstanceTypesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Outposts.GetOutpostSupportedInstanceTypesInput {
        return .init(
            assetId: self.assetId,
            maxResults: self.maxResults,
            nextToken: token,
            orderId: self.orderId,
            outpostIdentifier: self.outpostIdentifier
        )
    }
}

extension Outposts.ListAssetInstancesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Outposts.ListAssetInstancesInput {
        return .init(
            accountIdFilter: self.accountIdFilter,
            assetIdFilter: self.assetIdFilter,
            awsServiceFilter: self.awsServiceFilter,
            instanceTypeFilter: self.instanceTypeFilter,
            maxResults: self.maxResults,
            nextToken: token,
            outpostIdentifier: self.outpostIdentifier
        )
    }
}

extension Outposts.ListAssetsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Outposts.ListAssetsInput {
        return .init(
            hostIdFilter: self.hostIdFilter,
            maxResults: self.maxResults,
            nextToken: token,
            outpostIdentifier: self.outpostIdentifier,
            statusFilter: self.statusFilter
        )
    }
}

extension Outposts.ListBlockingInstancesForCapacityTaskInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Outposts.ListBlockingInstancesForCapacityTaskInput {
        return .init(
            capacityTaskId: self.capacityTaskId,
            maxResults: self.maxResults,
            nextToken: token,
            outpostIdentifier: self.outpostIdentifier
        )
    }
}

extension Outposts.ListCapacityTasksInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Outposts.ListCapacityTasksInput {
        return .init(
            capacityTaskStatusFilter: self.capacityTaskStatusFilter,
            maxResults: self.maxResults,
            nextToken: token,
            outpostIdentifierFilter: self.outpostIdentifierFilter
        )
    }
}

extension Outposts.ListCatalogItemsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Outposts.ListCatalogItemsInput {
        return .init(
            ec2FamilyFilter: self.ec2FamilyFilter,
            itemClassFilter: self.itemClassFilter,
            maxResults: self.maxResults,
            nextToken: token,
            supportedStorageFilter: self.supportedStorageFilter
        )
    }
}

extension Outposts.ListOrdersInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Outposts.ListOrdersInput {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            outpostIdentifierFilter: self.outpostIdentifierFilter
        )
    }
}

extension Outposts.ListOutpostsInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Outposts.ListOutpostsInput {
        return .init(
            availabilityZoneFilter: self.availabilityZoneFilter,
            availabilityZoneIdFilter: self.availabilityZoneIdFilter,
            lifeCycleStatusFilter: self.lifeCycleStatusFilter,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Outposts.ListSitesInput: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Outposts.ListSitesInput {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            operatingAddressCityFilter: self.operatingAddressCityFilter,
            operatingAddressCountryCodeFilter: self.operatingAddressCountryCodeFilter,
            operatingAddressStateOrRegionFilter: self.operatingAddressStateOrRegionFilter
        )
    }
}
